home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gxclbits.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-02  |  22.9 KB  |  718 lines
  1. /* Copyright (C) 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxclbits.c */
  20. /* Halftone and bitmap writing for command lists */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gpcheck.h"
  24. #include "gserrors.h"
  25. #include "gsbitops.h"
  26. #include "gxdevice.h"
  27. #include "gxdevmem.h"            /* must precede gxcldev.h */
  28. #include "gxcldev.h"
  29. #include "gxfmap.h"
  30.  
  31. /*
  32.  * Define when, if ever, to write character bitmaps in all bands.
  33.  * Set this to:
  34.  *    0 to always write in all bands;
  35.  *    N to write in all bands when the character has been seen in N+1
  36.  *       bands on a page;
  37.  *    max_ushort to never write in all bands.
  38.  */
  39. #define CHAR_ALL_BANDS_COUNT max_ushort
  40.  
  41. /* ------ Writing ------ */
  42.  
  43. /*
  44.  * Determine the (possibly unpadded) width in bytes for writing a bitmap,
  45.  * per the algorithm in gxcldev.h.  If compression_mask has any of the
  46.  * cmd_mask_compress_any bits set, we assume the bitmap will be compressed.
  47.  * Return the total size of the bitmap.
  48.  */
  49. uint
  50. clist_bitmap_bytes(uint width_bits, uint height, int compression_mask,
  51.   uint *width_bytes, uint *raster)
  52. {    uint full_raster = *raster = bitmap_raster(width_bits);
  53.     uint short_raster = (width_bits + 7) >> 3;
  54.     uint width_bytes_last;
  55.  
  56.     if ( compression_mask & cmd_mask_compress_any )
  57.       *width_bytes = width_bytes_last = full_raster;
  58.     else if ( short_raster <= cmd_max_short_width_bytes ||
  59.           height <= 1 ||
  60.           (compression_mask & decompress_spread) != 0
  61.         )
  62.       *width_bytes = width_bytes_last = short_raster;
  63.     else
  64.       *width_bytes = full_raster, width_bytes_last = short_raster;
  65.     return
  66.       (height == 0 ? 0 : *width_bytes * (height - 1) + width_bytes_last);
  67. }
  68.  
  69. /*
  70.  * Compress a bitmap, skipping extra padding bytes at the end of each row if
  71.  * necessary.  We require height >= 1, raster >= bitmap_raster(width_bits).
  72.  */
  73. private int
  74. cmd_compress_bitmap(stream_state *st, const byte *data, uint width_bits,
  75.   uint raster, uint height, stream_cursor_write *pw)
  76. {    uint width_bytes = bitmap_raster(width_bits);
  77.     int status = 0;
  78.     stream_cursor_read r;
  79.  
  80.     r.ptr = data - 1;
  81.     if ( raster == width_bytes )
  82.       { r.limit = r.ptr + raster * height;
  83.         status = (*st->template->process)(st, &r, pw, true);
  84.       }
  85.     else
  86.       { /* Compress row-by-row. */
  87.         uint y;
  88.         for ( y = 1; (r.limit = r.ptr + width_bytes), y < height; ++y )
  89.           { status = (*st->template->process)(st, &r, pw, false);
  90.         if ( status )
  91.           break;
  92.         if ( r.ptr != r.limit )
  93.           { /* We don't attempt to handle compressors that */
  94.             /* require >1 input byte to make progress. */
  95.             status = -1;
  96.             break;
  97.           }
  98.         r.ptr += raster - width_bytes;
  99.           }
  100.         if ( status == 0 )
  101.           status = (*st->template->process)(st, &r, pw, true);
  102.       }
  103.     if ( st->template->release )
  104.       (*st->template->release)(st);
  105.     return status;
  106. }
  107.  
  108. /*
  109.  * Put a bitmap in the buffer, compressing if appropriate.
  110.  * pcls == 0 means put the bitmap in all bands.
  111.  * Return <0 if error, otherwise the compression method.
  112.  * A return value of gs_error_limitcheck means that the bitmap was too big
  113.  * to fit in the command reading buffer.
  114.  * Note that this leaves room for the command and initial arguments,
  115.  * but doesn't fill them in.
  116.  */
  117. int
  118. cmd_put_bits(gx_device_clist_writer *cldev, gx_clist_state *pcls,
  119.   const byte *data, uint width_bits, uint height, uint raster, int op_size,
  120.   int compression_mask, byte **pdp, uint *psize)
  121. {    uint short_raster, full_raster;
  122.     uint short_size =
  123.       clist_bitmap_bytes(width_bits, height,
  124.                  compression_mask & ~cmd_mask_compress_any,
  125.                  &short_raster, &full_raster);
  126.     uint uncompressed_raster;
  127.     uint uncompressed_size =
  128.       clist_bitmap_bytes(width_bits, height, compression_mask,
  129.                  &uncompressed_raster, &full_raster);
  130.     uint max_size = cbuf_size - op_size;
  131.     byte *dp;
  132.     int compress = 0;
  133.  
  134.     /*
  135.      * See if compressing the bits is possible and worthwhile.
  136.      * Currently we can't compress if the compressed data won't fit in
  137.      * the command reading buffer, or if the decompressed data won't fit
  138.      * in the buffer and decompress_elsewhere isn't set.
  139.      */
  140.     if ( short_size >= 50 &&
  141.          (compression_mask & cmd_mask_compress_any) != 0 &&
  142.          (uncompressed_size <= max_size ||
  143.           (compression_mask & decompress_elsewhere) != 0)
  144.        )
  145.       {    union ss_ {
  146.           stream_state ss;
  147.           stream_CFE_state cf;
  148.           stream_RLE_state rl;
  149.         } sstate;
  150.  
  151.         *psize = op_size + uncompressed_size;
  152.         if ( pcls != 0 )
  153.           { set_cmd_put_op(dp, cldev, pcls, 0, *psize);
  154.           }
  155.         else
  156.           { set_cmd_put_all_op(dp, cldev, 0, *psize);
  157.           }
  158.         cmd_uncount_op(0, *psize);
  159.         /*
  160.          * Note that we currently keep all the padding if we are
  161.          * compressing.  This is ridiculous, but it's too hard to
  162.          * change right now.
  163.          */
  164.         if ( compression_mask & (1 << cmd_compress_cfe) )
  165.           { /* Try CCITTFax compression. */
  166.             clist_cfe_init(&sstate.cf,
  167.                    uncompressed_raster << 3 /*width_bits*/);
  168.             sstate.ss.template = &s_CFE_template;
  169.             compress = cmd_compress_cfe;
  170.           }
  171.         else if ( compression_mask & (1 << cmd_compress_rle) )
  172.           { /* Try RLE compression. */
  173.             clist_rle_init(&sstate.rl);
  174.             sstate.ss.template = &s_RLE_template;
  175.             compress = cmd_compress_rle;
  176.           }
  177.         if ( compress )
  178.           { byte *wbase = dp + (op_size - 1);
  179.             stream_cursor_write w;
  180.             /*
  181.              * We can give up on compressing if we generate too much
  182.              * output to fit in the command reading buffer, or too
  183.              * much to make compression worthwhile.
  184.              */
  185.             uint wmax = min(uncompressed_size, max_size);
  186.             int status;
  187.  
  188.             w.ptr = wbase;
  189.             w.limit = w.ptr + min(wmax, short_size >> 1);
  190.             status = cmd_compress_bitmap((stream_state *)&sstate, data,
  191.                          uncompressed_raster << 3 /*width_bits*/,
  192.                          raster, height, &w);
  193.             if ( status == 0 )
  194.               { /* Use compressed representation. */
  195.             uint wcount = w.ptr - wbase;
  196.             cmd_shorten_list_op(cldev,
  197.                 (pcls ? &pcls->list : &cldev->band_range_list),
  198.                 uncompressed_size - wcount);
  199.             *psize = op_size + wcount;
  200.             goto out;
  201.               }
  202.           }
  203.         if ( uncompressed_size > max_size )
  204.           { cmd_shorten_list_op(cldev,
  205.                 (pcls ? &pcls->list : &cldev->band_range_list),
  206.                 *psize);
  207.             return_error(gs_error_limitcheck);
  208.           }
  209.         if ( uncompressed_size != short_size )
  210.           {    cmd_shorten_list_op(cldev,
  211.                 (pcls ? &pcls->list : &cldev->band_range_list),
  212.                 uncompressed_size - short_size);
  213.             *psize = op_size + short_size;
  214.           }
  215.         compress = 0;
  216.       }
  217.     else if ( uncompressed_size > max_size )
  218.       return_error(gs_error_limitcheck);
  219.     else
  220.       {    *psize = op_size + short_size;
  221.         if ( pcls != 0 )
  222.           { set_cmd_put_op(dp, cldev, pcls, 0, *psize);
  223.           }
  224.         else
  225.           { set_cmd_put_all_op(dp, cldev, 0, *psize);
  226.           }
  227.         cmd_uncount_op(0, *psize);
  228.       }
  229.     bytes_copy_rectangle(dp + op_size, short_raster, data, raster,
  230.                  short_raster, height);
  231. out:    *pdp = dp;
  232.     return compress;
  233. }
  234.  
  235. /* Add a command to set the tile size and depth. */
  236. private uint
  237. cmd_size_tile_params(const gx_strip_bitmap *tile)
  238. {    return 2 + cmd_size_w(tile->rep_width) + cmd_size_w(tile->rep_height) +
  239.       (tile->rep_width == tile->size.x ? 0 :
  240.        cmd_size_w(tile->size.x / tile->rep_width)) +
  241.       (tile->rep_height == tile->size.y ? 0 :
  242.        cmd_size_w(tile->size.y / tile->rep_height)) +
  243.       (tile->rep_shift == 0 ? 0 : cmd_size_w(tile->rep_shift));
  244. }
  245. private void
  246. cmd_store_tile_params(byte *dp, const gx_strip_bitmap *tile, int depth,
  247.   uint csize)
  248. {    byte *p = dp + 2;
  249.     byte bd = depth - 1;
  250.  
  251.     *dp = cmd_count_op(cmd_opv_set_tile_size, csize);
  252.     p = cmd_put_w(tile->rep_width, p);
  253.     p = cmd_put_w(tile->rep_height, p);
  254.     if ( tile->rep_width != tile->size.x ) {
  255.       p = cmd_put_w(tile->size.x / tile->rep_width, p);
  256.       bd |= 0x20;
  257.     }
  258.     if ( tile->rep_height != tile->size.y ) {
  259.       p = cmd_put_w(tile->size.y / tile->rep_height, p);
  260.       bd |= 0x40;
  261.     }
  262.     if ( tile->rep_shift != 0 ) {
  263.       cmd_put_w(tile->rep_shift, p);
  264.       bd |= 0x80;
  265.     }
  266.     dp[1] = bd;
  267. }
  268.  
  269. /* Add a command to set the tile index. */
  270. /* This is a relatively high-frequency operation, so we make it a macro. */
  271. /* Note that it may do a 'return' with an error code. */
  272. /* Some compilers try to substitute macro args in string literals! */
  273. #define cmd_put_tile_index_inline(cldev, pcls, indx)\
  274.  { int idelta = (indx) - (pcls)->tile_index + 8; byte *dp;\
  275.    if ( !(idelta & ~15) )\
  276.      { set_cmd_put_op(dp, cldev, pcls, cmd_op_delta_tile_index + idelta, 1); }\
  277.    else\
  278.      { set_cmd_put_op(dp, cldev, pcls, cmd_op_set_tile_index + ((indx) >> 8), 2);\
  279.        dp[1] = (indx) & 0xff;\
  280.        if_debug2('L', "[L]writing index=%u, offset=%lu\n",\
  281.          indx, cldev->tile_table[indx].offset);\
  282.      }\
  283.  }
  284.  
  285. /* If necessary, write out data for a single color map. */
  286. int
  287. cmd_put_color_map(gx_device_clist_writer *cldev, cmd_map_index map_index,
  288.   const gx_transfer_map *map, gs_id *pid)
  289. {    byte *dp;
  290.  
  291.     if ( map == 0 )
  292.       { if ( pid )
  293.           { if ( *pid == gs_no_id )
  294.           return 0;        /* no need to write */
  295.             *pid = gs_no_id;
  296.           }
  297.         set_cmd_put_all_op(dp, cldev, cmd_opv_set_misc, 2);
  298.         dp[1] = cmd_set_misc_map + map_index;
  299.       }
  300.     else
  301.       { if ( pid )
  302.           { if ( map->id == *pid )
  303.           return 0;        /* no need to write */
  304.             *pid = map->id;
  305.           }
  306.         set_cmd_put_all_op(dp, cldev, cmd_opv_set_misc,
  307.                    2 + sizeof(map->values));
  308.         dp[1] = cmd_set_misc_map + 0x20 + map_index;
  309.         memcpy(dp + 2, map->values, sizeof(map->values));
  310.       }
  311.     return 0;
  312. }
  313.  
  314. /* ------ Tile cache management ------ */
  315.  
  316. /* We want consecutive ids to map to consecutive hash slots if possible, */
  317. /* so we can use a delta representation when setting the index. */
  318. #define tile_id_hash(id) (id)
  319. #define tile_hash_next(index) ((index) + 413)    /* arbitrary large odd # */
  320. typedef struct tile_loc_s {
  321.     uint index;
  322.     tile_slot *tile;
  323. } tile_loc;
  324.  
  325. /* Look up a tile or character in the cache.  If found, set the index and */
  326. /* pointer; if not, set the index to the insertion point. */
  327. private bool
  328. clist_find_bits(gx_device_clist_writer *cldev, gx_bitmap_id id, tile_loc *ploc)
  329. {    uint index = tile_id_hash(id);
  330.     const tile_hash *table = cldev->tile_table;
  331.     uint mask = cldev->tile_hash_mask;
  332.     ulong offset;
  333.  
  334.     for ( ; (offset = table[index &= mask].offset) != 0;
  335.           index = tile_hash_next(index)
  336.         )
  337.       { tile_slot *tile = (tile_slot *)(cldev->data + offset);
  338.         if ( tile->id == id )
  339.           { ploc->index = index;
  340.         ploc->tile = tile;
  341.         return true;
  342.           }
  343.       }
  344.     ploc->index = index;
  345.     return false;
  346. }
  347.  
  348. /* Delete a tile from the cache. */
  349. private void
  350. clist_delete_tile(gx_device_clist_writer *cldev, tile_slot *slot)
  351. {    tile_hash *table = cldev->tile_table;
  352.     uint mask = cldev->tile_hash_mask;
  353.     uint index = slot->index;
  354.     ulong offset;
  355.  
  356.     if_debug2('L', "[L]deleting index=%u, offset=%lu\n",
  357.           index, (ulong)((byte *)slot - cldev->data));
  358.     gx_bits_cache_free(&cldev->bits, (gx_cached_bits_head *)slot,
  359.                &cldev->chunk);
  360.     table[index].offset = 0;
  361.     /* Delete the entry from the hash table. */
  362.     /* We'd like to move up any later entries, so that we don't need */
  363.     /* a deleted mark, but it's too difficult to note this in the */
  364.     /* band list, so instead, we just delete any entries that */
  365.     /* would need to be moved. */
  366.     while ( (offset = table[index = tile_hash_next(index) & mask].offset) != 0 )
  367.       { tile_slot *tile = (tile_slot *)(cldev->data + offset);
  368.         tile_loc loc;
  369.         if ( !clist_find_bits(cldev, tile->id, &loc) )
  370.           { /* We didn't find it, so it should be moved into a slot */
  371.         /* that we just vacated; instead, delete it. */
  372.         if_debug2('L', "[L]move-deleting index=%u, offset=%lu\n",
  373.               index, offset);
  374.         gx_bits_cache_free(&cldev->bits,
  375.                 (gx_cached_bits_head *)(cldev->data + offset),
  376.                    &cldev->chunk);
  377.         table[index].offset = 0;
  378.           }
  379.       }
  380. }
  381.  
  382. /* Add a tile to the cache. */
  383. /* tile->raster holds the raster for the replicated tile; */
  384. /* we pass the raster of the actual data separately. */
  385. private int
  386. clist_add_tile(gx_device_clist_writer *cldev, const gx_strip_bitmap *tiles,
  387.   uint sraster, int depth)
  388. {    uint raster = tiles->raster;
  389.     uint size_bytes = raster * tiles->size.y;
  390.     uint tsize =
  391.       sizeof(tile_slot) + cldev->tile_band_mask_size + size_bytes;
  392.     gx_cached_bits_head *slot_head;
  393. #define slot ((tile_slot *)slot_head)
  394.  
  395.     if ( cldev->bits.csize == cldev->tile_max_count )
  396.       { /* Don't let the hash table get too full: delete an entry. */
  397.         /* Since gx_bits_cache_alloc returns an entry to delete when */
  398.         /* it fails, just force it to fail. */
  399.         gx_bits_cache_alloc(&cldev->bits, (ulong)cldev->chunk.size,
  400.                 &slot_head);
  401.         if ( slot_head == 0 )
  402.           { /* Wrap around and retry. */
  403.         cldev->bits.cnext = 0;
  404.         gx_bits_cache_alloc(&cldev->bits, (ulong)cldev->chunk.size,
  405.                     &slot_head);
  406. #ifdef DEBUG
  407.         if ( slot_head == 0 )
  408.           { lprintf("No entry to delete!\n");
  409.             return_error(gs_error_Fatal);
  410.           }
  411. #endif
  412.           }
  413.         clist_delete_tile(cldev, slot);
  414.       }
  415.     /* Allocate the space for the new entry, deleting entries as needed. */
  416.     while ( gx_bits_cache_alloc(&cldev->bits, (ulong)tsize, &slot_head) < 0 )
  417.       { if ( slot_head == 0 )
  418.           { /* Wrap around. */
  419.         if ( cldev->bits.cnext == 0 )
  420.           { /* Too big to fit.  We should probably detect this */
  421.             /* sooner, since if we get here, we've cleared the */
  422.             /* cache. */
  423.             return_error(gs_error_limitcheck);
  424.           }
  425.         cldev->bits.cnext = 0;
  426.           }
  427.         else
  428.           clist_delete_tile(cldev, slot);
  429.       }
  430.     /* Fill in the entry. */
  431.     slot->cb_depth = depth;
  432.     slot->cb_raster = raster;
  433.     slot->width = tiles->rep_width;
  434.     slot->height = tiles->rep_height;
  435.     slot->shift = slot->rep_shift = tiles->rep_shift;
  436.     slot->x_reps = slot->y_reps = 1;
  437.     slot->id = tiles->id;
  438.     memset(ts_mask(slot), 0, cldev->tile_band_mask_size);
  439.     bytes_copy_rectangle(ts_bits(cldev, slot), raster,
  440.                  tiles->data, sraster,
  441.                  (tiles->rep_width * depth + 7) >> 3,
  442.                  tiles->rep_height);
  443.     /* Make the hash table entry. */
  444.     { tile_loc loc;
  445. #ifdef DEBUG
  446.       if ( clist_find_bits(cldev, tiles->id, &loc) )
  447.         lprintf1("clist_find_bits(0x%lx) should have failed!\n",
  448.              (ulong)tiles->id);
  449. #else
  450.       clist_find_bits(cldev, tiles->id, &loc);    /* always fails */
  451. #endif
  452.       slot->index = loc.index;
  453.       cldev->tile_table[loc.index].offset =
  454.         (byte *)slot_head - cldev->data;
  455.       if_debug2('L', "[L]adding index=%u, offset=%lu\n",
  456.             loc.index, cldev->tile_table[loc.index].offset);
  457.     }
  458.     slot->num_bands = 0;
  459.     return 0;
  460. }
  461.  
  462. /* ------ Driver procedure support ------ */
  463.  
  464. /* Change the tile parameters (size and depth). */
  465. /* Currently we do this for all bands at once. */
  466. private void
  467. clist_new_tile_params(gx_strip_bitmap *new_tile, const gx_strip_bitmap *tiles,
  468.   int depth, const gx_device_clist_writer *cldev)
  469. {    /*
  470.      * Adjust the replication factors.  If we can, we replicate
  471.      * the tile in X up to 32 bytes, and then in Y up to 4 copies,
  472.      * as long as we don't exceed a total tile size of 256 bytes,
  473.      * or more than 255 repetitions in X or Y, or make the tile so
  474.      * large that not all possible tiles will fit in the cache.
  475.      * Also, don't attempt Y replication if shifting is required. 
  476.      */
  477. #define max_tile_reps_x 255
  478. #define max_tile_bytes_x 32
  479. #define max_tile_reps_y 4
  480. #define max_tile_bytes 256
  481.     uint rep_width = tiles->rep_width;
  482.     uint rep_height = tiles->rep_height;
  483.     uint rep_width_bits = rep_width * depth;
  484.     uint tile_overhead =
  485.       sizeof(tile_slot) + cldev->tile_band_mask_size;
  486.     uint max_bytes = cldev->chunk.size / (rep_width_bits * rep_height);
  487.  
  488.     max_bytes -= min(max_bytes, tile_overhead);
  489.     if ( max_bytes > max_tile_bytes )
  490.       max_bytes = max_tile_bytes;
  491.     *new_tile = *tiles;
  492.     { uint max_bits_x = max_bytes * 8 / rep_height;
  493.       uint reps_x =
  494.         min(max_bits_x, max_tile_bytes_x * 8) / rep_width_bits;
  495.       uint reps_y;
  496.  
  497.       while ( reps_x > max_tile_reps_x )
  498.         reps_x >>= 1;
  499.       new_tile->size.x = max(reps_x, 1) * rep_width;
  500.       new_tile->raster = bitmap_raster(new_tile->size.x * depth);
  501.       if ( tiles->shift != 0 )
  502.         reps_y = 1;
  503.       else
  504.         { reps_y = max_bytes / (new_tile->raster * rep_height);
  505.           if ( reps_y > max_tile_reps_y )
  506.         reps_y = max_tile_reps_y;
  507.           else if ( reps_y < 1 )
  508.         reps_y = 1;
  509.         }
  510.       new_tile->size.y = reps_y * rep_height;
  511.     }
  512. #undef max_tile_reps_x
  513. #undef max_tile_bytes_x
  514. #undef max_tile_reps_y
  515. #undef max_tile_bytes
  516. }
  517.  
  518. /* Change tile for clist_tile_rectangle. */
  519. int
  520. clist_change_tile(gx_device_clist_writer *cldev, gx_clist_state *pcls,
  521.   const gx_strip_bitmap *tiles, int depth)
  522. {    tile_loc loc;
  523.     int code;
  524.  
  525. #define tile_params_differ(cldev, tiles, depth)\
  526.   ((tiles)->rep_width != (cldev)->tile_params.rep_width ||\
  527.    (tiles)->rep_height != (cldev)->tile_params.rep_height ||\
  528.    (tiles)->rep_shift != (cldev)->tile_params.rep_shift ||\
  529.    (depth) != (cldev)->tile_depth)
  530.  
  531. top:    if ( clist_find_bits(cldev, tiles->id, &loc) )
  532.       { /* The bitmap is in the cache.  Check whether this band */
  533.         /* knows about it. */
  534.         int band_index = pcls - cldev->states;
  535.         byte *bptr = ts_mask(loc.tile) + (band_index >> 3);
  536.         byte bmask = 1 << (band_index & 7);
  537.  
  538.         if ( *bptr & bmask )
  539.           { /* Already known.  Just set the index. */
  540.         if ( pcls->tile_index == loc.index )
  541.           return 0;
  542.         cmd_put_tile_index_inline(cldev, pcls, loc.index);
  543.           }
  544.         else
  545.           { uint extra = 0;
  546.             if tile_params_differ(cldev, tiles, depth)
  547.           { /*
  548.              * We have a cached tile whose parameters differ from
  549.              * the current ones.  Because of the way tile IDs are
  550.              * managed, this is currently only possible when mixing
  551.              * Patterns and halftones, but if we didn't generate new
  552.              * IDs each time the main halftone cache needed to be
  553.              * refreshed, this could also happen simply from
  554.              * switching screens.
  555.              */
  556.             int band;
  557.  
  558.             clist_new_tile_params(&cldev->tile_params, tiles, depth,
  559.                       cldev);
  560.             cldev->tile_depth = depth;
  561.             /* No band knows about the new parameters. */
  562.             for ( band = cldev->tile_known_min;
  563.               band <= cldev->tile_known_max;
  564.               ++band
  565.             )
  566.               cldev->states[band].known &= ~tile_params_known;
  567.             cldev->tile_known_min = cldev->nbands;
  568.             cldev->tile_known_max = -1;
  569.           }
  570.         if ( !(pcls->known & tile_params_known) )
  571.           { /* We're going to have to write the tile parameters. */
  572.             extra = cmd_size_tile_params(&cldev->tile_params);
  573.           }
  574.             { /*
  575.            * This band doesn't know this tile yet, so output the
  576.            * bits.  Note that the offset we write is the one used by
  577.            * the reading phase, not the writing phase.  Note also
  578.            * that the size of the cached and written tile may differ
  579.            * from that of the client's tile.  Finally, note that
  580.            * this tile's size parameters are guaranteed to be
  581.            * compatible with those stored in the device
  582.            * (cldev->tile_params).
  583.            */
  584.           ulong offset = (byte *)loc.tile - cldev->chunk.data;
  585.           uint rsize =
  586.             extra + 1 + cmd_size_w(loc.index) + cmd_size_w(offset);
  587.           byte *dp;
  588.           uint csize;
  589.           int code =
  590.             cmd_put_bits(cldev, pcls, ts_bits(cldev, loc.tile),
  591.                  tiles->rep_width * depth, tiles->rep_height,
  592.                  loc.tile->cb_raster, rsize,
  593.                  (cldev->tile_params.size.x > tiles->rep_width ?
  594.                   decompress_elsewhere | decompress_spread :
  595.                   decompress_elsewhere),
  596.                  &dp, &csize);
  597.  
  598.           if ( code < 0 )
  599.             return code;
  600.           if ( extra )
  601.             { /* Write the tile parameters before writing the bits. */
  602.               cmd_store_tile_params(dp, &cldev->tile_params, depth,
  603.                         extra);
  604.               dp += extra;
  605.               /* This band now knows the parameters. */
  606.               pcls->known |= tile_params_known;
  607.               if ( band_index < cldev->tile_known_min )
  608.             cldev->tile_known_min = band_index;
  609.               if ( band_index > cldev->tile_known_max )
  610.             cldev->tile_known_max = band_index;
  611.             }
  612.           *dp = cmd_count_op(cmd_opv_set_tile_bits, csize - extra);
  613.           dp++;
  614.           dp = cmd_put_w(loc.index, dp);
  615.           cmd_put_w(offset, dp);
  616.           *bptr |= bmask;
  617.           loc.tile->num_bands++;
  618.         }
  619.           }
  620.         pcls->tile_index = loc.index;
  621.         pcls->tile_id = loc.tile->id;
  622.         return 0;
  623.       }
  624.     /* The tile is not in the cache, add it. */
  625.     { gx_strip_bitmap new_tile;
  626.       gx_strip_bitmap *ptile;
  627.  
  628.       /* Ensure that the tile size is compatible. */
  629.       if ( tile_params_differ(cldev, tiles, depth) )
  630.         { /* We'll reset cldev->tile_params when we write the bits. */
  631.           clist_new_tile_params(&new_tile, tiles, depth, cldev);
  632.           ptile = &new_tile;
  633.         }
  634.       else
  635.         { cldev->tile_params.id = tiles->id;
  636.           cldev->tile_params.data = tiles->data;
  637.           ptile = &cldev->tile_params;
  638.         }
  639.       code = clist_add_tile(cldev, ptile, tiles->raster, depth);
  640.       if ( code < 0 )
  641.         return code;
  642.     }
  643.     goto top;
  644. #undef tile_params_differ
  645. }
  646.  
  647. /* Change "tile" for clist_copy_*.  tiles->[rep_]shift must be zero. */
  648. int
  649. clist_change_bits(gx_device_clist_writer *cldev, gx_clist_state *pcls,
  650.   const gx_strip_bitmap *tiles, int depth)
  651. {    tile_loc loc;
  652.     int code;
  653.  
  654. top:    if ( clist_find_bits(cldev, tiles->id, &loc) )
  655.       { /* The bitmap is in the cache.  Check whether this band */
  656.         /* knows about it. */
  657.         uint band_index = pcls - cldev->states;
  658.         byte *bptr = ts_mask(loc.tile) + (band_index >> 3);
  659.         byte bmask = 1 << (band_index & 7);
  660.  
  661.         if ( *bptr & bmask )
  662.           { /* Already known.  Just set the index. */
  663.         if ( pcls->tile_index == loc.index )
  664.           return 0;
  665.         cmd_put_tile_index_inline(cldev, pcls, loc.index);
  666.           }
  667.         else
  668.           { /* Not known yet.  Output the bits. */
  669.         /* Note that the offset we write is the one used by */
  670.         /* the reading phase, not the writing phase. */
  671.         ulong offset = (byte *)loc.tile - cldev->chunk.data;
  672.         uint rsize = 2 + cmd_size_w(loc.tile->width) +
  673.           cmd_size_w(loc.tile->height) + cmd_size_w(loc.index) +
  674.             cmd_size_w(offset);
  675.         byte *dp;
  676.         uint csize;
  677.         gx_clist_state *bit_pcls = pcls;
  678.         int code;
  679.  
  680.         if ( loc.tile->num_bands == CHAR_ALL_BANDS_COUNT )
  681.           bit_pcls = NULL;
  682.         code = cmd_put_bits(cldev, bit_pcls, ts_bits(cldev, loc.tile),
  683.                     loc.tile->width * depth,
  684.                     loc.tile->height, loc.tile->cb_raster,
  685.                     rsize,
  686.                     (1 << cmd_compress_cfe) | decompress_elsewhere,
  687.                     &dp, &csize);
  688.  
  689.         if ( code < 0 )
  690.           return code;
  691.         *dp = cmd_count_op(cmd_opv_set_bits, csize);
  692.         dp[1] = (depth << 2) + code;
  693.         dp += 2;
  694.         dp = cmd_put_w(loc.tile->width, dp);
  695.         dp = cmd_put_w(loc.tile->height, dp);
  696.         dp = cmd_put_w(loc.index, dp);
  697.         cmd_put_w(offset, dp);
  698.         if ( bit_pcls == NULL )
  699.           { memset(ts_mask(loc.tile), 0xff,
  700.                cldev->tile_band_mask_size);
  701.             loc.tile->num_bands = cldev->nbands;
  702.           }
  703.         else
  704.           { *bptr |= bmask;
  705.             loc.tile->num_bands++;
  706.           }
  707.           }
  708.         pcls->tile_index = loc.index;
  709.         pcls->tile_id = loc.tile->id;
  710.         return 0;
  711.       }
  712.     /* The tile is not in the cache. */
  713.     code = clist_add_tile(cldev, tiles, tiles->raster, depth);
  714.     if ( code < 0 )
  715.       return code;
  716.     goto top;
  717. }
  718.